home *** CD-ROM | disk | FTP | other *** search
/ Mac OS 9 Serial Number Archive / SN Archive 2023.11.04.toast / BSNG / SDK / BSNG SDK 2.5 / Libraries / standard utils / standard utils.c next >
Encoding:
C/C++ Source or Header  |  1998-02-05  |  23.0 KB  |  946 lines  |  [TEXT/CWIE]
  1. /*
  2.  * $Workfile:: standard utils.c                                               $
  3.  * $Revision:: 1                                                              $
  4.  *
  5.  * $Author:: Buck Rogers                                                      $
  6.  * $Modtime:: 30.09.1997 17:49 Uhr                                            $
  7.  *
  8.  * $History:: standard utils.c                                                $
  9.  * 
  10.  * *****************  Version 1  *****************
  11.  * User: Buck Rogers  Date: 30.09.1997   Time: 18:31 Uhr
  12.  * Created in $/BSNG/Plugins/BSNG SDK/Libraries/standard utils
  13.  * Adding subproject 'BSNG' to '$/'
  14.  *
  15.  * $NoKeywords::                                                              $
  16.  */
  17.  
  18.  
  19. #include "UltraU.h"
  20. #include "standard utils.h"
  21.  
  22.  
  23. /* ************************************************************************************************ */
  24. //RANDOM NUMBER GENERATION UTILITIES
  25.                      
  26. Boolean myBooleanRandom(void)
  27. {
  28.     return ((Boolean) Ultra_short1());
  29. }
  30.  
  31. unsigned short myShortRangedRandom(unsigned short min,unsigned short max)
  32. {
  33. register unsigned short        qdRdm;        //treat return value as 0-65536
  34. register unsigned long        range,t;
  35.  
  36.     qdRdm =(unsigned short) Ultra_short16();
  37.     range =max-min;
  38.     if (range != 1) t = (qdRdm * range) >> 16;        //now 0 <= t <= range
  39.     else            t = (qdRdm % 2);
  40.     return (t+min);
  41. }
  42.  
  43. unsigned long myLongRangedRandom(unsigned long min,unsigned long max)
  44. {
  45. register unsigned long    t,range=max-min;
  46.     
  47.     if (range < (1L << 16)) t=min + (unsigned long) ((unsigned short) myShortRangedRandom(0,range));
  48.     else
  49.     {
  50.         do {
  51.             t=(((unsigned long)myShortRangedRandom(0,range>>16))<<16) | myShortRangedRandom(0,range&0xFFFF);
  52.             t+=min;
  53.         } while ((t<min)||(t>max));
  54.     }
  55.     return (t);
  56. }
  57.  
  58. /* ************************************************************************************************ */
  59. //INTEGER/WHOLE NUMBER MATHEMATICAL/MANIPULATION ROUTINES
  60.  
  61. unsigned long myABSL(signed long n)
  62. {
  63.     return ((n >= 0) ? n : -n);
  64. }
  65.  
  66. unsigned short myABSW(signed short n)
  67. {
  68.     return ((n >= 0) ? n : -n);
  69. }
  70.  
  71. //warning in the bit rotation routines I have not bothered to do arguement reduction on b
  72. //so if you pass an out of range b, you will always get zero.  I may change this at some point, so
  73. //do not depend upon this 'functionality'
  74.  
  75. //the next two calls provide particularily wierd yet commonly used operation that is identical to
  76. //the rotate operation with the important differences being that the sign is used to borrow when
  77. //doing the right shifting components of the two operations and instead of oring we exclusive-or
  78.  
  79. unsigned char myArithROLB(unsigned char n,unsigned short b)
  80. {
  81.     register signed char    v=(signed char) n;
  82.     
  83.     return ((v << b) ^ (v >> (8 - b)));
  84. }
  85.  
  86. unsigned char myArithRORB(unsigned char n,unsigned short b)
  87. {
  88.     register signed char    v=(signed char) n;
  89.     
  90.     return ((v >> b) ^ (v << (8 - b)));
  91. }
  92.  
  93. unsigned char myROLB(unsigned char n,unsigned short b)
  94. {
  95.     register unsigned char    v=n;
  96.     
  97.     return ((v << b) | (v >> (8 - b)));
  98. }
  99.  
  100. unsigned char myRORB(unsigned char n,unsigned short b)
  101. {
  102.     register unsigned char    v=n;
  103.     
  104.     return ((v >> b) | (v << (8 - b)));
  105. }
  106.  
  107. unsigned short myROLW(unsigned short n,unsigned short b)
  108. {
  109.     register unsigned short    v=n;
  110.     
  111.     return ((v << b) | (v >> (16 - b)));
  112. }
  113.  
  114. unsigned short myRORW(unsigned short n,unsigned short b)
  115. {
  116.     register unsigned short    v=n;
  117.     
  118.     return ((v >> b) | (v << (16 - b)));
  119. }
  120.  
  121. unsigned long myROLL(unsigned long n,unsigned short b)
  122. {
  123.     register unsigned long    v=n;
  124.     
  125.     return ((v << b) | (v >> (32 - b)));
  126. }
  127.  
  128. unsigned long myROLLByteX(unsigned long n,unsigned short theByte,unsigned short b)
  129. {
  130.     register unsigned short    j=theByte * 8;
  131.     register unsigned long    u=n;
  132.     register unsigned char    v=(unsigned char) ((u >> j) & 0x000000FF);
  133.     
  134.     return ((u ^ (v << j)) | ((((v << b) | (v >> (8 - b))) & 0x000000FF) << j));
  135. }
  136.  
  137. unsigned long myROLLWordX(unsigned long n,unsigned short theWord,unsigned short b)
  138. {
  139.     register unsigned short    j=theWord * 16;
  140.     register unsigned long    u=n;
  141.     register unsigned short    v=(unsigned short) ((u >> j) & 0x0000FFFF);
  142.     
  143.     return ((u ^ (v << j)) | ((((v << b) | (v >> (16 - b))) & 0x0000FFFF) << j));
  144. }
  145.  
  146. unsigned long myRORL(unsigned long n,unsigned short b)
  147. {
  148.     register unsigned long    v=n;
  149.     
  150.     return ((v >> b) | (v << (32 - b)));
  151. }
  152.  
  153. unsigned long myRORLByteX(unsigned long n,unsigned short theByte,unsigned short b)
  154. {
  155.     register unsigned short    j=theByte * 8;
  156.     register unsigned long    u=n;
  157.     register unsigned char    v=(unsigned char) ((u >> j) & 0x000000FF);
  158.     
  159.     return ((u ^ (v << j)) | ((((v >> b) | (v << (8 - b))) & 0x000000FF) << j));
  160. }
  161.  
  162. unsigned long myRORLWordX(unsigned long n,unsigned short theWord,unsigned short b)
  163. {
  164.     register unsigned short    j=theWord * 16;
  165.     register unsigned long    u=n;
  166.     register unsigned short    v=(unsigned short) ((u >> j) & 0x0000FFFF);
  167.     
  168.     return ((u ^ (v << j)) | ((((v >> b) | (v << (16 - b))) & 0x0000FFFF) << j));
  169. }
  170.  
  171. unsigned long myIntegerSquareRoot(unsigned long n)    //extremely poor sqrRoot algorithm
  172. {
  173. register unsigned long v,sqr;
  174.  
  175.     v=n/2;
  176.     sqr=v*v;
  177.     while (sqr>n)
  178.     {
  179.         v=v/2;
  180.         sqr=v*v;
  181.     }
  182.     while (sqr<n)
  183.     {
  184.         v+=1;
  185.         sqr=v*v;
  186.     }
  187.     if (sqr>n) v--;
  188.     return v;
  189. }
  190.  
  191. unsigned long myClosestIntegerSquareRoot(unsigned long n)    //extremely poor algorithm
  192. {
  193. register unsigned long v,sqr;
  194.  
  195.     v=myIntegerSquareRoot(n);                                    //now    v*v <= n < (v+1)*(v+1)
  196.     sqr=v*v;
  197.     if ((n-sqr) > (sqr + (v<<1) +1 - n)) v++;                //v=v+1 iff (n-v*v) > ((v+1)*(v+1) - n)
  198.     return v;    
  199.     //note (sqr + (v<<1) +1) = v*v + 2*v + 1 = (v+1) * (v+1)
  200. }
  201.  
  202. /* ************************************************************************************************ */
  203. //NUMERIC STRING and NUMBER<-->STRING ROUTINES
  204.  
  205. unsigned short myBaseXCharToVal(unsigned char c)    //c should be '0'..'9','A'..'Z','a'..'z'
  206. {
  207.     if (c<='9') return (c-'0');
  208.     if (c<='Z') return (c-'A'+10);
  209.     if (c<='z') return (c-'a'+36);
  210.     return (0);
  211. }
  212.  
  213. /*
  214.     StringToNum() is well defined even for non-numeric strings and is equivalent to:
  215. */
  216. long myPStrToNum(const Str255 s)
  217. {
  218.     return myCharsToNum((StringPtr) &s[1],s[0]);
  219. }
  220.  
  221. long myCharsToNum(const StringPtr s,unsigned short numDigits)
  222. {
  223. register long    v;
  224. register short    i,len=numDigits;
  225. register short    sign=s[0];
  226.  
  227.     v=0;
  228.     if (len)
  229.     {
  230.         if ((sign=='+')||(sign=='-'))
  231.         {
  232.             for (i=1;i<len;i++) v=(v*10)+(s[i]&0x0F);    //note &0x0F==%16 but &0x0F is faster
  233.             if (sign=='-') v*=-1;
  234.         }
  235.         else for (i=0;i<len;i++) v=(v*10)+(s[i]&0x0F);    //note &0x0F==%16 but &0x0F is faster    
  236.     }
  237.     return v;
  238. }
  239.  
  240. long myDigitsToNum(const StringPtr s,unsigned short numDigits)
  241. {
  242.     return myBaseBDigitsToNum(s,10,numDigits);
  243. }
  244.  
  245. long myBaseBPStrToNum(const Str255 s,unsigned short b)
  246. {
  247.     return myBaseBDigitsToNum((StringPtr) &s[1],b,s[0]);
  248. }
  249.  
  250. long myBaseBDigitsToNum(const StringPtr s,unsigned short b,unsigned short numDigits)
  251. {
  252. register unsigned long    v = 0;                //defined so v can hold a positive 32 bit number
  253. register short            i,len=numDigits;
  254. register short            sign=s[0];
  255.  
  256.     if (len)
  257.     {
  258.         if ((sign == '+') || (sign == '-'))
  259.         {
  260.             for (i = 1; i < len; i++)  v = (v * b) + myBaseXCharToVal(s[i]);
  261.             if (sign == '-') return (- ((signed long) v));
  262.         }
  263.         else for (i = 0; i < len; i++) v = (v * b) + myBaseXCharToVal(s[i]);
  264.     }
  265.     return ((signed long) v);
  266. }
  267.  
  268. void myBaseBRandomPStr(Str255 s,unsigned short b,unsigned short numDigits)
  269. {
  270.     s[0]=numDigits;
  271.     myBaseBRandomDigits(&s[1],b,numDigits);
  272. }
  273.  
  274. void myBaseBRandomDigits(StringPtr s,unsigned short b,unsigned short numDigits)
  275. {
  276. register short    i;
  277. register short    max = b - 1;
  278.  
  279.     for (i=numDigits-1;i>=0;i--) s[i] = myValToBaseXChar(myShortRangedRandom(0,max));
  280. }
  281.  
  282. void mySFBaseBRandomPStr(Str255 s,unsigned short b,unsigned short numSigDigits)
  283. {
  284.     s[0]=numSigDigits;
  285.     mySFBaseBRandomDigits(&s[1],b,numSigDigits);
  286. }
  287.  
  288. void mySFBaseBRandomDigits(StringPtr s,unsigned short b,unsigned short numSigDigits)
  289. {
  290. register short    i;
  291. register short    max = b - 1;
  292.  
  293.     for (i=numSigDigits-1;i>=1;i--) s[i] = myValToBaseXChar(myShortRangedRandom(0,max));
  294.     s[0] = myValToBaseXChar(myShortRangedRandom(1,max));
  295. }
  296.  
  297. unsigned char myRandom09Char(void)
  298. {
  299.     return ((unsigned char) myShortRangedRandom('0','9'));
  300. }
  301.  
  302. unsigned char myRandomAZChar(void)
  303. {
  304.     return ((unsigned char) myShortRangedRandom('A','Z'));
  305. }
  306.  
  307. unsigned char myRandom09AZChar(void)
  308. {
  309. unsigned char    c;
  310.  
  311.     c = myShortRangedRandom(0,35);
  312.     c+= (c < 10) ? '0' : 'A'-10;
  313.     return (c);
  314. }
  315.  
  316. void myZeroPadPStr(Str255 s,unsigned short paddedLength)
  317. {
  318. register short    paddingLength=paddedLength-s[0];
  319.  
  320.     if (paddingLength>0)
  321.     {
  322.         BlockMove((Ptr) &s[1],(Ptr) &s[paddingLength+1],s[0]);
  323.         s[0]+=paddingLength;
  324.         while (paddingLength>0) s[paddingLength--]='0';
  325.     }
  326. }
  327.  
  328. unsigned char myValToBaseXChar(unsigned short v)
  329. {
  330.     if (v<10) return ('0'+v);        //00..09  -> '0'..'9'
  331.     if (v<36) return ('A'-10+v);    //10..35  -> 'A'..'Z'
  332.     return ('a'-36+v);                //36..61+ -> 'a'..'z'+
  333. }
  334.  
  335. void mySNumToPStr(long num,Str255 s,unsigned short minDigits)
  336. {
  337.     if (num >= 0)
  338.     {
  339.         NumToString(num,s);
  340.         myZeroPadPStr(s,minDigits);
  341.     }
  342.     else
  343.     {
  344.         NumToString(-num,s);
  345.         myZeroPadPStr(s,minDigits);
  346.         if (s[1]=='0') s[1]='-';
  347.         else myPrefixPStr(s,"\p-");
  348.     }
  349.  
  350. }
  351.  
  352. void myUNumToPStr(unsigned long n,Str255 s,unsigned short minDigits)
  353. {
  354.     s[0] = myUNumToDigits(n,&s[1],minDigits);
  355. }
  356.  
  357. void myUNumToBaseBPStr(unsigned long n,Str255 s,unsigned short b,unsigned short minDigits)
  358. { 
  359.     s[0] = myUNumToBaseBDigits(n,&s[1],b,minDigits);
  360. }
  361.  
  362. unsigned short myUNumToDigits(unsigned long n,StringPtr s,unsigned short minDigits)
  363. {
  364. register char    numStr[10];        //only 10 decimal digits are possible from unsigned 32 bits
  365. register short    start,i,j=0;
  366.  
  367.     do
  368.     {
  369.         numStr[j++]='0'+(n%10);
  370.         n/=10;
  371.     } while (n>0);
  372.     start=(j<minDigits) ? (minDigits-j) : 0;
  373.     for (i=0;i<start;i++) s[i]='0';
  374.     for (i=start;j>0;i++) s[i]=numStr[--j];
  375.     return (i);
  376. }
  377.  
  378. unsigned short myUNumToBaseBDigits(unsigned long n,StringPtr s,unsigned short b,unsigned short minDigits)
  379. {
  380. register char    numStr[32];        //32 binary digits are possible from unsigned 32 bits
  381. register short    start,i,j=0;
  382.  
  383.     if ((b<2) || (b>62)) return (0);    //error - illegal base was passed
  384.     do
  385.     {
  386.         numStr[j++]=myValToBaseXChar(n%b);
  387.         n/=b;
  388.     } while (n>0);
  389.     start=(j<minDigits) ? (minDigits-j) : 0;
  390.     for (i=0;i<start;i++) s[i]='0';
  391.     for (i=start;j>0;i++) s[i]=numStr[--j];
  392.     return (i);
  393. }
  394.  
  395. unsigned long mySumOfPStr(const Str255 s)                        //does not include the length byte
  396. {
  397. register unsigned long    result=0;
  398. register unsigned short    i;
  399.     
  400.     for (i = s[0]; i > 0; i--) result+=s[i];
  401.     return (result);
  402. }
  403.  
  404. unsigned long myIndexWeightedSumOfPStr(const Str255 s)            //does not include the length byte
  405. {
  406. register unsigned long    result=0;
  407. register unsigned short    i;
  408.     
  409.     for (i = s[0]; i > 0; i--) result+=i * s[i];
  410.     return (result);
  411. }
  412.  
  413. unsigned long mySumOfChars(const StringPtr s,unsigned short numChars)
  414. {
  415. register unsigned long    result=0;
  416. register unsigned short    i;
  417.     
  418.     for (i = 0; i < numChars; i++) result+=s[i];
  419.     return (result);
  420. }
  421.  
  422. unsigned long mySumOfBaseXPStr(const Str255 s)                    //does not include the length byte
  423. {
  424. register unsigned long    result=0;
  425. register unsigned short    i;
  426.     
  427.     for (i = s[0]; i > 0; i--) result+=myBaseXCharToVal(s[i]);
  428.     return (result);
  429. }
  430.  
  431. unsigned long mySumOfBaseXDigits(const StringPtr s,unsigned short numDigits)
  432. {
  433. register unsigned long    result=0;
  434. register unsigned short    i;
  435.     
  436.     for (i = 0; i < numDigits; i++) result+=myBaseXCharToVal(s[i]);
  437.     return (result);
  438. }
  439.  
  440. unsigned long my4BytesAsUNum(const StringPtr s)
  441. {
  442. register unsigned long    v;
  443. register StringPtr        c=s;
  444.  
  445.     v =*(c++)<<8;
  446.     v|=*(c++);
  447.     v<<=8;
  448.     v|=*(c++);
  449.     v<<=8;
  450.     v|=*c;
  451.     return (v);
  452. }
  453.  
  454. unsigned long my2BytesAsUNum(const StringPtr s)
  455. {
  456. register unsigned long    v;
  457. register StringPtr        c=s;
  458.     
  459.     v =*(c++)<<8;
  460.     v|=*c;
  461.     return (v);
  462. }
  463.  
  464. /* ************************************************************************************************ */
  465. //STRING MANIPULATION ROUTINES
  466.  
  467. unsigned long cStrLen(const Ptr s,unsigned long maxLen)
  468. {
  469. register Ptr c=s;
  470. register unsigned long len=0;
  471.     
  472.     while ((len < maxLen) && ((Byte *) *(c++)!=0x00)) len++;
  473.     return len;
  474. }
  475.  
  476. void myCStrToPStr(unsigned char *s)
  477. {
  478. unsigned char    *t = s;
  479. unsigned char    *p = s;
  480. unsigned long    len;
  481.  
  482.     while (*t != 0) t++;
  483.     len = t - s;
  484.     p = t;
  485.     while (p != s) *(p--) = *(--t);
  486.     if (len > 255)
  487.     {
  488.         DebugStr("\pmyCStrToPStr: string to long");
  489.         len = 255;
  490.     }
  491.     s[0] = len;
  492. }
  493.  
  494. void myCopyPStr(const Str255 s,Str255 t)
  495. {
  496.     BlockMove((Ptr) s,(Ptr) t,s[0]+1);
  497. }
  498.  
  499. Boolean myEqualPStr(const Str255 s,const Str255 t)
  500. {
  501. register short    i=s[0];
  502.  
  503.     if (s[0]==t[0])
  504.     {
  505.         while ((i>0) && (s[i]==t[i])) i--;
  506.         return ((Boolean)(i==0));
  507.     }
  508.     return (FALSE);
  509. }
  510.  
  511. short myFindFirstInPStr(const Str255 s,unsigned char c)
  512. {
  513.     register short    i    =1;
  514.     register short    len    =s[0];
  515.     
  516.     while ((i <= len) && (s[i] != c)) i++;
  517.     return ((i > len) ? 0 : i);
  518. }
  519.  
  520. short myFindLastInPStr(const Str255 s,unsigned char c)
  521. {
  522.     register short    i    =s[0];
  523.     
  524.     while ((i > 0) && (s[i] != c)) i--;
  525.     return (i);
  526. }
  527.  
  528. void myGetPStrSubString(const Str255 s,short first,unsigned short numChars,Str255 subStr)
  529. {
  530. register unsigned short    i,len=s[0];
  531. register unsigned short    j;
  532. register unsigned short    end;
  533.  
  534.     if (first == 0) DebugStr("\pBad parameter passsed to myGetPStrSubString");
  535.     if (first < 0)                                //first is an offset from the end of s
  536.     {
  537.         first+=len + 1;                            //map (-n..-1) to (1..len)
  538.         if (first <= 0) first = 1;                //requesting more chars than available - truncate
  539.     }
  540.     if ((len==0) || (first>len)) subStr[0]=0;    //s is null or first out of range -- return empty s
  541.     else
  542.     {
  543.         if (numChars == 0) numChars=len-first+1;//if (numChars == 0) subStr[1..n]=s[first..len]
  544.         end=first + numChars - 1;
  545.         if (end>len)                            //requesting more chars than available -- truncate
  546.         {
  547.             numChars-=end-len;
  548.             end=len;
  549.         }
  550.         for (i=end,j=numChars;i>=first;i--,j--) subStr[j]=s[i];
  551.         subStr[0]=numChars;
  552.     }
  553. }
  554.  
  555. void myPrefixPStr(Str255 s,const Str255 prefixStr)
  556. {
  557. register unsigned short    i=s[0];
  558. register unsigned short    j=prefixStr[0];
  559.     
  560.     if (j)
  561.     {
  562.         if ((i+j) <= 255)                                //if room to prefix
  563.         {
  564.             BlockMove((Ptr) &s[1],(Ptr) &s[j+1],i);
  565.             BlockMove((Ptr) &prefixStr[1],(Ptr) &s[1],j);    
  566.             s[0]+=j;
  567.         }
  568.         else DebugStr("\pOverflow");
  569.     }
  570. }
  571.  
  572. void myAppendPStr(Str255 s,const Str255 suffixStr)
  573. {
  574. register unsigned short    i=s[0];
  575. register unsigned short    j=suffixStr[0];
  576.     
  577.     if (j)
  578.     {
  579.         if ((i+j) <= 255)                                //if room to append
  580.         {
  581.             BlockMove((Ptr) &suffixStr[1],(Ptr) &s[i+1],j);
  582.             s[0]+=j;
  583.         }
  584.         else DebugStr("\pOverflow");
  585.     }
  586. }
  587.  
  588. void myAppendCharToPStr(Str255 s,unsigned char c)
  589. {
  590.     if (s[0] < 255) s[++s[0]] = c;
  591.     else DebugStr("\pOverflow");
  592. }
  593.  
  594. void myAppendQuotedPStr(Str255 s,const Str255 suffixStr)
  595. {
  596. register short        j=suffixStr[0];
  597.     
  598.     if ((j) && ((s[0]+2+j)<=255))    //if room to append
  599.     {
  600.         s[++s[0]] ='\'';
  601.         BlockMove((Ptr) &suffixStr[1],(Ptr) &s[++s[0]],j);    //note this pre-adds 1 to s[0]
  602.         s[s[0]+=j]='\'';                                    //index calculation also sets s[0]
  603.     }
  604. }
  605.  
  606. void myInsertInPStr(Str255 s,const Str255 insertStr,short offset)    //does an 'insert before'
  607. {
  608. register short    start,insertLen=insertStr[0];
  609. register short    len=s[0];
  610.  
  611.     if (insertLen > 0)
  612.     {
  613.         if (offset <= 0)                        //insert at 'offset' chars from end of s
  614.         {
  615.             start = len + offset + 1;
  616.             if (start < 1) start = 1;            //underflow - prefix        
  617.         }    
  618.         else                                    //insert at 'offset' chars from start of s
  619.         {
  620.             if (offset > len) offset = len + 1;    //overflow - suffix
  621.             start = offset;                
  622.         }
  623.         if (start <= len) BlockMove((Ptr) &s[start],(Ptr) &s[start+insertLen],len-start+1);    //make room for insertStr
  624.         BlockMove((Ptr) &insertStr[1],(Ptr) &s[start],insertLen);                             //copy inserStr into s
  625.         s[0]+=insertLen;
  626.     }
  627. }
  628.  
  629. void myBracketPStrWithChar(Str255 s,unsigned char c,signed short numBefore,signed short numAfter)
  630. {
  631. register short    i,j,len=s[0];
  632.     
  633.     if (numBefore < 0) numBefore = 0;
  634.     if (numAfter  < 0) numAfter = 0;    
  635.     if ((len + numBefore + numAfter) < 256)
  636.     {
  637.         if (numBefore)
  638.         {
  639.             i=len;                                                //i=initial length
  640.             len+=numBefore;                                        //set len=prefixed length
  641.             for (j=len; (i>0); i--) s[j--]=s[i];                //slide existing string forward
  642.             while (j>0) s[j--]=c;                                //write prefix
  643.         }
  644.         for (i=len,j=numAfter; j > 0 ; j--) s[++i]=c;            //write suffix
  645.         s[0]=i;                                                    //adjust length;
  646.     }
  647. }
  648.  
  649. void myUnBracketPStrWithChar(Str255 s,unsigned char c,Boolean doBefore,Boolean doAfter)
  650. {
  651. register unsigned short    len    = s[0];
  652. register unsigned char    *t    =&s[1];
  653.     
  654.     if (doAfter)
  655.     {
  656.         while ((len > 0) && (s[len] == c)) len--;
  657.         s[0]=len;
  658.     }
  659.     if (doBefore)
  660.     {
  661.         while ((len > 0) && (*(t++) == c)) len--;    
  662.         //note: len != s[0] implies that *(--t) is the first non-c character in s    
  663.         if (len != s[0])    
  664.         {
  665.             BlockMove((Ptr) --t,(Ptr) &s[1],len);
  666.             s[0]=len;
  667.         }
  668.     }
  669. }
  670.  
  671. void myStripCharFromPStr(Str255 s,unsigned char c)
  672. {
  673. register unsigned short        i,j,len = s[0];
  674.  
  675.     for (i = 1, j = 0; i <= len; i++) if (s[i] != c) s[++j] = s[i];
  676.     s[0] = j;
  677. }
  678.  
  679. void myDeleteElementFromPStr(Str255 s,unsigned short index)
  680. {
  681. register unsigned short        i,len = s[0];
  682.  
  683.     if (index <= len)
  684.     {
  685.         for (i = index; i < len; i++) s[i] = s[i + 1];
  686.         s[0]--;
  687.     }
  688. }
  689.  
  690.  
  691. void myUpCasePStr(Str255 s)
  692. {
  693. short            i;
  694.  
  695.     for (i=s[0];i>0;i--) if ((s[i]>='a') && (s[i]<='z')) s[i]-='a'-'A';
  696. }
  697.  
  698. void myLoCasePStr(Str255 s)
  699. {
  700. register short    i;
  701.  
  702.     for (i=s[0];i>0;i--) if ((s[i]>='A') && (s[i]<='Z')) s[i]+='a'-'A';
  703. }
  704.  
  705. void myTitleCasePStr(Str255 s)
  706. {
  707. register short    i=1;
  708. register short    len=s[0];
  709.  
  710.     if (len)
  711.     {
  712.         myLoCasePStr(s);
  713.         while (i<=len)
  714.         {
  715.             if ((s[i]>='a') && (s[i]<='z')) s[i]-='a'-'A';    //capitalize the ith character
  716.             while ((i<=len)  && (s[i]!=' ')) i++;            //skip until space
  717.             while ((i<=len)  && (s[i]==' ')) i++;            //skip spaces
  718.         }
  719.     }
  720. }
  721.  
  722. void myTruncatePStr(Str255 s,unsigned short maxLength)
  723. {
  724.     if (s[0] > (unsigned short) maxLength) s[0]=(unsigned char) maxLength;
  725. }
  726.  
  727. void myReversePStr(Str255 s)
  728. {
  729. register short            i,j;
  730. register unsigned char    t;
  731.  
  732.     for (i=s[0],j=1 ;i>j; i--,j++)    //note this algorithm will not waste time exchanging
  733.     {                                //a len=1 string or middle element with itself
  734.         t=s[i];
  735.         s[i]=s[j];
  736.         s[j]=t;
  737.     } 
  738. }
  739.  
  740. void myMapPStr(Str255 s,unsigned short *permIndexes)
  741. {
  742. register unsigned short    i,len = s[0];
  743. register Str255            t;
  744.  
  745.     //do the permutation
  746.     for (i = 0; i <= len; i++) t[i] = s[permIndexes[i]];
  747.     //t may or may not be a PStr now, so do a direct copy
  748.     BlockMove( (Ptr) t, (Ptr) s, len + 1);
  749. }
  750.  
  751. void myInversePermutatePStr(Str255 s,unsigned short *permIndexes)
  752. {
  753. register unsigned short    i,len = s[0];
  754. register Str255            t;
  755.  
  756.     //do the permutation
  757.     for (i = 0; i <= len; i++) t[permIndexes[i]] = s[i];
  758.     //t may or may not be a PStr now, so do a direct copy
  759.     BlockMove( (Ptr) t, (Ptr) s, len + 1);
  760. }
  761.  
  762. /* ************************************************************************************************ */
  763. //RESOURCE ROUTINES
  764.  
  765. Boolean mySaveResource(const Handle theResource)
  766. {
  767.     short    resAttributes;
  768.     Boolean itWorked;
  769.     
  770.     resAttributes=GetResAttrs(theResource);
  771.     if (resAttributes&resProtected)
  772.     {
  773.         SetResAttrs(theResource,resAttributes ^ resProtected);    //set as unprotected
  774.         ChangedResource(theResource);
  775.         itWorked=(Boolean) (ResError()==noErr); 
  776.         if (itWorked) WriteResource(theResource);
  777.         SetResAttrs(theResource,resAttributes);    //set as protected
  778.         //this setting will be saved even though we don't call changed/write resource
  779.     }
  780.     else 
  781.     {
  782.         ChangedResource(theResource);
  783.         itWorked=(Boolean) (ResError()==noErr); 
  784.         if (itWorked) WriteResource(theResource);
  785.     }
  786.     if (!itWorked) DebugStr("\pError returned by ChangedResource - cannot save");
  787.     return itWorked;
  788. }
  789.  
  790. /* ************************************************************************************************ */
  791. //STANDARD FILE ROUTINES
  792.  
  793. Boolean myPutFile(FSSpec *theFSSPtr,OSType type,OSType creator,const Str255 prompt,const Str255 defaultName)
  794. {
  795.     StandardFileReply     outputReply;
  796.     OSErr                errorCode=noErr;
  797.     
  798. putFile:
  799.     StandardPutFile(prompt,defaultName,&outputReply);
  800.     if (outputReply.sfGood)
  801.     {
  802.         if (outputReply.sfReplacing)
  803.         {
  804.             errorCode=FSpDelete(&(outputReply.sfFile));
  805.             if (errorCode!=noErr)
  806.             {
  807.                 SysBeep(10);    
  808.                 goto putFile;
  809.             }    
  810.         }
  811.         errorCode=FSpCreate(&(outputReply.sfFile),creator,type,outputReply.sfScript);
  812.         *theFSSPtr=outputReply.sfFile;                                    //copy the FSS
  813.     }
  814.     return ((outputReply.sfGood)&&(errorCode==noErr));
  815. }
  816.  
  817. Boolean myGetFile(FSSpec *theFSSPtr)
  818. {
  819.     SFTypeList            typeList;
  820.     StandardFileReply     reply;
  821.     
  822.     StandardGetFile(nil,-1,typeList,&reply);
  823.     *theFSSPtr=reply.sfFile;                                            //copy the FSS 
  824.     return ((reply.sfGood)&&(!reply.sfIsFolder)&&(!reply.sfIsVolume));    //file was selected?
  825. }
  826.  
  827. /* ************************************************************************************************ */
  828. //FILE ROUTINES 
  829.  
  830. OSErr myCloseFile(short *fileRefNum,FSSpec *fileFSSpec)
  831. {
  832.     OSErr    errorCode;
  833.     
  834.     errorCode=FSClose(*fileRefNum);
  835.     *fileRefNum=0;                            //safety to prevent double closing which can trash HD's
  836.     if (errorCode!=noErr) DebugStr("\pError closing file");
  837.     errorCode=FlushVol(nil,fileFSSpec->vRefNum);                      //ensure file data is written
  838.     if (errorCode!=noErr) DebugStr("\pError flushing volume");
  839.     return (errorCode);
  840. }
  841.  
  842. OSErr myOpenResFile(FSSpec *inputFSSPtr,short permission,short *inputRefNumPtr)
  843. {
  844.     short    oldResFile;
  845.     OSErr    errorCode=noErr;
  846.     
  847.     oldResFile=CurResFile();
  848.     SetResLoad(FALSE);                            //stop resources in users file from auto preloading
  849.     *inputRefNumPtr=FSpOpenResFile(inputFSSPtr,permission);
  850.     if (*inputRefNumPtr==-1) errorCode=ResError();
  851.     SetResLoad(TRUE);                            //resume normal loading of resources
  852.     UseResFile(oldResFile);
  853.     return errorCode;
  854. }
  855.  
  856. /* ************************************************************************************************ */
  857. //TEXT FILE OUTPUT ROUTINES
  858.  
  859. void myOutputPStr(short outputRefNum,const Str255 s)
  860. {
  861.     long    inOutCount=(long) s[0];
  862.     OSErr    errorCode;
  863.     
  864.     if (inOutCount!=0)
  865.     {
  866.         errorCode = FSWrite(outputRefNum,&inOutCount,&s[1]);
  867.         if (errorCode!=noErr) DebugStr("\pError during write");
  868.     }
  869. }
  870.  
  871. void myOutputSuffixedPStr(short outputRefNum,const Str255 s,const Str255 suffixStr)
  872. {
  873.     long    inOutCount=(long) s[0];
  874.     OSErr    errorCode;
  875.     
  876.     if (inOutCount!=0)
  877.     {
  878.         errorCode = FSWrite(outputRefNum,&inOutCount,&s[1]);
  879.         if (errorCode!=noErr) DebugStr("\pError during write");
  880.         else
  881.         {
  882.             inOutCount=(long) suffixStr[0];
  883.             if (inOutCount!=0)
  884.             {
  885.                 errorCode = FSWrite(outputRefNum,&inOutCount,&suffixStr[1]);
  886.                 if (errorCode!=noErr) DebugStr("\pError during write");
  887.             }
  888.         }
  889.     }
  890. }
  891.  
  892. void myOutputText(short outputRefNum,const Ptr TextPtr,unsigned long textLen)
  893. {
  894.     long    inOutCount=(long) textLen;
  895.     OSErr    errorCode;
  896.     
  897.     if (inOutCount!=0)
  898.     {
  899.         errorCode = FSWrite(outputRefNum,&inOutCount,TextPtr);
  900.         if (errorCode!=noErr) DebugStr("\pError during write");
  901.     }
  902. }
  903.  
  904. void myOutputSuffixedText(short outputRefNum,const Ptr TextPtr,unsigned long textLen,const Str255 suffixStr)
  905. {
  906.     long    inOutCount=(long) textLen;
  907.     OSErr    errorCode;
  908.     
  909.     if (textLen!=0)
  910.     {
  911.         errorCode = FSWrite(outputRefNum,&inOutCount,TextPtr);
  912.         if (errorCode!=noErr) DebugStr("\pError during write");
  913.         else
  914.         {
  915.             inOutCount=(long) suffixStr[0];
  916.             if (inOutCount!=0)
  917.             {
  918.                 errorCode = FSWrite(outputRefNum,&inOutCount,&suffixStr[1]);
  919.                 if (errorCode!=noErr) DebugStr("\pError during write");
  920.             }
  921.         }
  922.     }
  923. }
  924.  
  925. void myOutputResHeader(short outputRefNum,OSType theType,short theID,const Str255 theName)
  926. {
  927.     Str255        idStr,headerStr={"\p'????' #"};
  928.     const short    offsetToOSType=2;    //offset into headerStr at which to copy the OSType
  929.     long        inOutCount;
  930.     OSErr        errorCode;
  931.     
  932.     BlockMove((Ptr) &theType,(Ptr) (headerStr+offsetToOSType),4);    //copy OSType into headerStr
  933.     NumToString((long) theID,idStr);
  934.     myAppendPStr(headerStr,idStr);
  935.     if (theName[0]!=0)
  936.     {
  937.         myAppendPStr(headerStr,"\p '");
  938.         myAppendPStr(headerStr,theName);
  939.         myAppendPStr(headerStr,"\p'");
  940.     }
  941.     myAppendPStr(headerStr,"\p\r\r");
  942.     inOutCount=headerStr[0];
  943.     errorCode = FSWrite(outputRefNum,&inOutCount,(Ptr) &headerStr[1]);
  944.     if (errorCode!=noErr) DebugStr("\pError during write");
  945. }
  946.